home *** CD-ROM | disk | FTP | other *** search
/ Kit PC World De Ampliacion De Windows 95 / Kit PC World de ampliacion de Windows 95.iso / internet / sweeper / samples / olecon~1 / framewrk / internet.cpp < prev    next >
C/C++ Source or Header  |  1995-12-05  |  9KB  |  465 lines
  1. #include "IPServer.H"
  2. #include "Internet.H"
  3. #include "Util.H"
  4.  
  5.  
  6. static VARTYPE rgI4[] = { VT_I4 }; 
  7.  
  8. typedef enum {
  9.     InternetEvent_Progress = 0,
  10.     InternetEvent_ReadyStateChange = 1
  11. } INTERNETEVENTS;
  12.  
  13. static EVENTINFO rgEvents [] = {
  14.     { DISPID_PROGRESS, 1, rgI4 },            // (long percentDone)
  15.     { DISPID_READYSTATECHANGE, 1, rgI4 },    // (OLE_READYSTATE newState)
  16. };
  17.  
  18.  
  19. // local class for doing async monitoring. It's not really all that
  20. // general purpose, but it does the job...
  21.  
  22.  
  23. class CDownloadSink : public IBindStatusCallback
  24. {
  25. public:
  26.     CDownloadSink(IUnknown *punkOuter,CInternetControl *,DISPID );
  27.     ~CDownloadSink();
  28.  
  29.     STDMETHOD(QueryInterface)(REFIID riid, void **ppvObjOut);
  30.     STDMETHOD_(ULONG, AddRef)();
  31.     STDMETHOD_(ULONG, Release)();
  32.  
  33.     STDMETHOD(GetBindInfo)( 
  34.          DWORD * grfBINDF,
  35.          BINDINFO *pbindinfo);
  36.     
  37.     STDMETHOD(OnStartBinding)( 
  38.          IBinding *pib);
  39.     
  40.     STDMETHOD(GetPriority)( 
  41.          LONG *pnPriority);
  42.     
  43.     STDMETHOD(OnProgress)( 
  44.          ULONG ulProgress,
  45.          ULONG ulProgressMax,
  46.          ULONG ulStatusCode,
  47.          LPCWSTR pwzStatusText);
  48.     
  49.     STDMETHOD(OnDataAvailable )( 
  50.         DWORD grfBSCF,
  51.         DWORD dwSize,
  52.         FORMATETC *pfmtetc,
  53.         REFIID riid,
  54.         IUnknown *punk);
  55.         
  56.      STDMETHOD(OnLowResource)( 
  57.          DWORD reserved);
  58.     
  59.     STDMETHOD(OnStopBinding)( 
  60.          HRESULT hrError);
  61.  
  62.     CDownloadSink * Next()                    { return(m_next); }
  63.     void            Next(CDownloadSink *n)  { m_next = n; }
  64.  
  65.     DISPID            DispId()  { return(m_propId); }
  66.     IBinding *        Binding() { return(m_binding); }
  67.  
  68. private:
  69.  
  70.     CDownloadSink *        m_next;
  71.     CInternetControl *    m_control;
  72.     DISPID                m_propId;
  73.     IBinding *            m_binding;
  74.     DWORD                m_ref;
  75.  
  76. };
  77.  
  78.  
  79. CDownloadSink::CDownloadSink
  80. (
  81.     IUnknown *            punkOuter,
  82.     CInternetControl *    control, 
  83.     DISPID                propId
  84. )
  85. {
  86. //    CHECK_POINTER(control);
  87.  
  88.     m_control = control;
  89.     m_control->AddRef();
  90.  
  91.     m_propId  = propId;
  92.     m_next    = 0;
  93.     m_binding = 0;
  94.     m_ref     = 0;
  95. }
  96.  
  97. CDownloadSink::~CDownloadSink()
  98. {
  99.     if( m_control )
  100.         m_control->Release();
  101.     if( m_binding )
  102.         m_binding->Release();
  103. }
  104.  
  105. STDMETHODIMP
  106. CDownloadSink::QueryInterface(const GUID &iid,void **ppv )
  107. { 
  108.     if( IsEqualGUID(iid,IID_IUnknown) || IsEqualGUID(iid,IID_IBindStatusCallback) )
  109.     {
  110.         *ppv = this;
  111.         AddRef();
  112.         return(NOERROR);
  113.     }
  114.     return( E_NOINTERFACE );
  115. }
  116.  
  117. STDMETHODIMP_(ULONG)
  118. CDownloadSink::AddRef()
  119. {
  120.     return(++m_ref);
  121. }
  122.  
  123. STDMETHODIMP_(ULONG)
  124. CDownloadSink::Release()
  125. {
  126.     if(!--m_ref)
  127.     {
  128.         delete this;
  129.         return(0);
  130.     }
  131.     return( m_ref );
  132. }
  133.     
  134.  
  135. STDMETHODIMP 
  136. CDownloadSink::GetBindInfo( DWORD *grfBINDF, BINDINFO *pbindInfo)
  137. {
  138.     *grfBINDF = BINDF_ASYNCHRONOUS;
  139.     pbindInfo->szExtraInfo = 0;
  140.     return(NOERROR);
  141. }
  142.  
  143.  
  144. STDMETHODIMP
  145. CDownloadSink::OnStartBinding(IBinding *pib) 
  146. {
  147.     m_binding = pib;
  148.     pib->AddRef();
  149.     return(NOERROR);
  150. }
  151.  
  152.  
  153. STDMETHODIMP 
  154. CDownloadSink::GetPriority( LONG *pnPriority) 
  155. {
  156.     return(E_NOTIMPL);
  157. }
  158.  
  159. STDMETHODIMP 
  160. CDownloadSink::OnProgress
  161. ( 
  162.      ULONG ulProgress,
  163.      ULONG ulProgressMax,
  164.      ULONG ulStatusCode,
  165.      LPCWSTR pwzStatusText
  166. ) 
  167. {
  168.     return(m_control->OnProgress(m_propId,ulProgress,
  169.                             ulProgressMax,ulStatusCode,pwzStatusText) );
  170. }
  171.  
  172. STDMETHODIMP 
  173. CDownloadSink::OnDataAvailable
  174. ( 
  175.      DWORD            grfBSCF,
  176.      DWORD            dwSize,
  177.      FORMATETC *    pFmtetc,
  178.      REFIID            iid,
  179.      IUnknown *        punk
  180. ) 
  181. {
  182.     return(m_control->OnData(m_propId,grfBSCF,(IStream *)punk, dwSize ));
  183. }
  184.  
  185. STDMETHODIMP 
  186. CDownloadSink::OnLowResource( DWORD reserved) 
  187. {
  188.     m_binding->Abort();
  189.     return(S_OK);
  190. }
  191.  
  192. STDMETHODIMP 
  193. CDownloadSink::OnStopBinding(HRESULT hrError) 
  194. {
  195.     m_binding->Release();
  196.     m_binding = 0;
  197.     m_control->Release();
  198.     m_control = 0;
  199.  
  200.     return(NOERROR);
  201. }
  202.  
  203.  
  204.  
  205. //------------------------------------------------------
  206. //
  207. // class CInternetControl
  208. //
  209. //
  210. CInternetControl::CInternetControl
  211. (
  212.     IUnknown *    pUnkOuter, 
  213.     int            iPrimaryDispatch, 
  214.     void *        pMainInterface
  215. )
  216.     : COleControl(pUnkOuter,iPrimaryDispatch,pMainInterface)
  217. {
  218.     m_downloads = 0;
  219.     m_host = 0;
  220.     m_readyState = READYSTATE_LOADING;
  221. }
  222.  
  223. CInternetControl::~CInternetControl()
  224. {
  225.     if( m_downloads )
  226.     {
  227.         CDownloadSink * next;
  228.         do 
  229.         {
  230.             next = m_downloads->Next();
  231.             IBinding * binding = m_downloads->Binding();
  232.             if( binding )
  233.                 binding->Abort();
  234.             m_downloads->Release();
  235.  
  236.         } while ( (m_downloads = next) != 0 );
  237.     }
  238.  
  239.     if( m_host )
  240.         m_host->Release();
  241. }
  242.  
  243.  
  244. HRESULT CInternetControl::InternalQueryInterface
  245. (
  246.     REFIID  riid,
  247.     void  **ppvObjOut
  248. )
  249. {
  250.     IUnknown *pUnk;
  251.  
  252.     *ppvObjOut = NULL;
  253.  
  254.     if (DO_GUIDS_MATCH(riid, IID_IServiceProvider)) {
  255.         pUnk = (IUnknown *)(IServiceProvider *)this;
  256.     } else{
  257.         return COleControl::InternalQueryInterface(riid, ppvObjOut);
  258.     }
  259.  
  260.     pUnk->AddRef();
  261.     *ppvObjOut = (void *)pUnk;
  262.     return S_OK;
  263. }
  264.  
  265. STDMETHODIMP 
  266. CInternetControl::QueryService(REFGUID guidService,
  267.             REFIID riid, void **ppvObject)
  268. {
  269.     HRESULT hr;
  270.  
  271.     IServiceProvider * clientsProvider;
  272.  
  273.     hr = m_pClientSite->QueryInterface(IID_IServiceProvider,
  274.                                             (void**)&clientsProvider );
  275.  
  276.     if( SUCCEEDED(hr) )
  277.     {
  278.         hr = clientsProvider->QueryService(guidService,
  279.                                     riid,ppvObject);
  280.         clientsProvider->Release();
  281.     }
  282.  
  283.     return(hr);
  284. }
  285.  
  286.  
  287. HRESULT 
  288. CInternetControl::GetBindHost(IBindHost ** pHost )
  289. {
  290.     HRESULT hr;
  291.     if( !m_host )
  292.         hr = GetBindHost();
  293.     else
  294.         hr = NOERROR;
  295.     *pHost = m_host;
  296.     return(hr);
  297. }
  298.  
  299. HRESULT 
  300. CInternetControl::GetBindHost()
  301. {
  302.     if( m_host )
  303.         return(NOERROR);
  304.  
  305.     IServiceProvider * serviceProvider = 0;
  306.  
  307.     HRESULT hr = m_pClientSite->QueryInterface
  308.                                     (
  309.                                         IID_IServiceProvider,
  310.                                         (void**)&serviceProvider
  311.                                     );
  312.  
  313.     if( SUCCEEDED(hr) )
  314.         hr = serviceProvider->QueryService( SID_BindHost, IID_IBindHost,
  315.                                             (void**)&m_host );
  316.     else
  317.         hr = E_FAIL; // C_E_UNKNOWNSERVICE;
  318.  
  319.     return(hr);
  320. }
  321.  
  322. HRESULT CInternetControl::GetAMoniker( LPOLESTR url, IMoniker ** ppmkr )
  323. {
  324.     HRESULT hr = GetBindHost();
  325.  
  326.     if( SUCCEEDED(hr) )
  327.         hr = m_host->ParseDisplayName(url,ppmkr);
  328.  
  329.     if( FAILED(hr) )
  330.        // FUTURE: This really should be a call to MkParseDisplayNameEx!!!
  331.         hr = ::CreateURLMoniker(0,url,ppmkr); 
  332.  
  333.     return( hr );
  334. }
  335.  
  336.  
  337. HRESULT CInternetControl::SetupDownload( IMoniker * moniker, DISPID propId )
  338. {
  339.     HRESULT hr = GetBindHost();
  340.  
  341.     IBindCtx * pBindCtx = 0;
  342.  
  343.     if( SUCCEEDED(hr) )
  344.         hr = m_host->GetBindCtx(0,&pBindCtx);
  345.  
  346.     if( FAILED(hr) )
  347.         hr = ::CreateBindCtx(0,&pBindCtx);
  348.  
  349.     CDownloadSink * sink = 0;
  350.  
  351.     if( SUCCEEDED(hr) )
  352.     {
  353.         sink = new CDownloadSink(0,this,propId);
  354.         if( sink )
  355.             sink->AddRef();
  356.     }
  357.  
  358.     if( SUCCEEDED(hr) && !sink )
  359.         hr = E_OUTOFMEMORY;
  360.     
  361.     if( SUCCEEDED(hr) )
  362.     {
  363.         // FUTURE: This should be a call to RegisterBindStatusCallback!!
  364.  
  365.         hr = pBindCtx->RegisterObjectParam(OLESTR("BindStatusCallback"), sink );
  366.     }
  367.         
  368.     IStream * strm = 0;
  369.  
  370.     if( SUCCEEDED(hr) )
  371.         hr = moniker->BindToStorage( pBindCtx, 0, IID_IStream, (void**)&strm );
  372.  
  373.     if( strm )
  374.         strm->Release();
  375.  
  376.     if( pBindCtx )
  377.         pBindCtx->Release();
  378.  
  379.     if( FAILED(hr) && sink )
  380.         sink->Release();
  381.  
  382.     if( SUCCEEDED(hr) )
  383.     {
  384.         if( m_downloads )
  385.             m_downloads->Next(sink);
  386.         m_downloads = sink;
  387.     }
  388.  
  389.     return(hr);
  390.  
  391. }
  392.  
  393. HRESULT CInternetControl::SetupDownload( LPOLESTR url, DISPID propId )
  394. {
  395.     CHECK_POINTER(url);
  396.  
  397.     IMoniker * pmkr;
  398.  
  399.     HRESULT hr = GetAMoniker( url, &pmkr );
  400.  
  401.     if( SUCCEEDED(hr) )
  402.         return( SetupDownload(pmkr,propId) );
  403.  
  404.     return(hr);
  405.  
  406. }
  407.  
  408. HRESULT CInternetControl::SetupDownload( IStream * propStream, DISPID propId )
  409. {
  410.     CHECK_POINTER(propStream);
  411.  
  412.     IMoniker * pmkr;
  413.  
  414.     HRESULT hr = ::OleLoadFromStream(propStream,IID_IMoniker,(void**)&pmkr);
  415.  
  416.     if( SUCCEEDED(hr) )
  417.         return( SetupDownload(pmkr,propId) );
  418.  
  419.     return(hr);
  420. }
  421.  
  422.  
  423. HRESULT CInternetControl::OnData( DISPID, DWORD,IStream *, DWORD)
  424. {
  425.     return(NOERROR);
  426. }
  427.  
  428. HRESULT CInternetControl::OnProgress( DISPID, ULONG progress, ULONG themax, ULONG, LPCWSTR)
  429. {
  430.     return(NOERROR);
  431. }
  432.  
  433. HRESULT CInternetControl::GetBinding(DISPID dispId,IBinding** ppBinding)
  434. {
  435.     CHECK_POINTER(ppBinding);
  436.  
  437.     CDownloadSink * sink = m_downloads;
  438.  
  439.     while(sink)
  440.     {
  441.         if( sink->DispId() == dispId )
  442.         {
  443.             if( (*ppBinding = sink->Binding()) == 0 )
  444.                 return( E_PENDING );
  445.             return(S_OK);
  446.         }
  447.         sink = sink->Next();
  448.     }
  449.  
  450.     return(E_FAIL);
  451. }
  452.  
  453.  
  454. HRESULT    CInternetControl::FireReadyStateChange( long newState )
  455. {
  456.     FireEvent( &::rgEvents[InternetEvent_ReadyStateChange], m_readyState = newState );
  457.     return(S_OK);
  458. }
  459.  
  460. HRESULT CInternetControl::FireProgress( ULONG dwAmount )
  461. {
  462.     FireEvent( &::rgEvents[InternetEvent_Progress], dwAmount );
  463.     return(S_OK);
  464. }
  465.